package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade NUMERO_SERIE_SOLICITACAO
 * @author Gerado pelo Telescope
 */
public class EntNumeroSerieSolicitacao extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.NUMERO_SERIE_SOLICITACAO";
    public final static String TABLE_NAME = "NUMERO_SERIE_SOLICITACAO";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntNumeroSerieSolicitacao() {
        super();
        initialize();
    }
    
    public EntNumeroSerieSolicitacao(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aSolicitacaoEnsaioId = new DomId(this,"SOLICITACAO_ENSAIO_ID", "Solicitação de ensaio"); 
        aSolicitacaoEnsaioId.setRequired(true);
        oSolicitacaoEnsaioId = new DomId();
        aAno = new DomInteger(this,"ANO", "Ano do número de série"); 
        aAno.setRequired(true);
        oAno = new DomInteger();
        aSequenciaInicialReservada = new DomInteger(this,"SEQUENCIA_INICIAL_RESERVADA", "Sequência inicial reservada"); 
        aSequenciaInicialReservada.setRequired(true);
        oSequenciaInicialReservada = new DomInteger();
        aSequenciaFinalReservada = new DomInteger(this,"SEQUENCIA_FINAL_RESERVADA", "Sequência final reservada"); 
        aSequenciaFinalReservada.setRequired(true);
        oSequenciaFinalReservada = new DomInteger();
        aUltimaSequenciaUtilizada = new DomInteger(this,"ULTIMA_SEQUENCIA_UTILIZADA", "Última sequencia utilizada"); 
        aUltimaSequenciaUtilizada.setRequired(true);
        oUltimaSequenciaUtilizada = new DomInteger();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Solicitação de ensaio
    private DomId aSolicitacaoEnsaioId;
    private DomId oSolicitacaoEnsaioId;
    
    // Ano do número de série
    private DomInteger aAno;
    private DomInteger oAno;
    
    // Sequência inicial reservada
    private DomInteger aSequenciaInicialReservada;
    private DomInteger oSequenciaInicialReservada;
    
    // Sequência final reservada
    private DomInteger aSequenciaFinalReservada;
    private DomInteger oSequenciaFinalReservada;
    
    // Última sequencia utilizada
    private DomInteger aUltimaSequenciaUtilizada;
    private DomInteger oUltimaSequenciaUtilizada;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntNumeroSerieSolicitacao id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SOLICITACAO_ENSAIO_ID">
    
    public EntNumeroSerieSolicitacao solicitacaoEnsaioId(Long value) {
        setSolicitacaoEnsaioId(value);
        return this;
    }
    
    public void setSolicitacaoEnsaioId(DomId value) {
        if (value == null || value.isNull()) {
            nullifySolicitacaoEnsaioId();
        } else {
            aSolicitacaoEnsaioId.setValue(value.getValue());
            if (aSolicitacaoEnsaioId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSolicitacaoEnsaioId(String value) {
        if (value == null) {
            nullifySolicitacaoEnsaioId();
        } else {
            aSolicitacaoEnsaioId.setValue(value);
            if (aSolicitacaoEnsaioId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSolicitacaoEnsaioId(Long value) {
        aSolicitacaoEnsaioId.setValue(value);
        if (aSolicitacaoEnsaioId.isModified()) {
            setModified(true);
        }
    }
    
    public void setSolicitacaoEnsaioId(Object value) {
        aSolicitacaoEnsaioId.setValue(value);
        if (aSolicitacaoEnsaioId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySolicitacaoEnsaioId() {
        if (!aSolicitacaoEnsaioId.isNull()) {
            aSolicitacaoEnsaioId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getSolicitacaoEnsaioId() {
        return aSolicitacaoEnsaioId;
    }
    
    public DomId oldSolicitacaoEnsaioId() {
        return oSolicitacaoEnsaioId;
    }
    
    public Long valueOfSolicitacaoEnsaioId() {
        return aSolicitacaoEnsaioId.getValue();
    }
    
    public boolean isSolicitacaoEnsaioIdModified() {
        return aSolicitacaoEnsaioId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ANO">
    
    public EntNumeroSerieSolicitacao ano(Integer value) {
        setAno(value);
        return this;
    }
    
    public void setAno(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyAno();
        } else {
            aAno.setValue(value.getValue());
            if (aAno.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setAno(String value) {
        if (value == null) {
            nullifyAno();
        } else {
            aAno.setValue(value);
            if (aAno.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setAno(Integer value) {
        aAno.setValue(value);
        if (aAno.isModified()) {
            setModified(true);
        }
    }
    
    public void setAno(Object value) {
        aAno.setValue(value);
        if (aAno.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyAno() {
        if (!aAno.isNull()) {
            aAno.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getAno() {
        return aAno;
    }
    
    public DomInteger oldAno() {
        return oAno;
    }
    
    public Integer valueOfAno() {
        return aAno.getValue();
    }
    
    public boolean isAnoModified() {
        return aAno.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SEQUENCIA_INICIAL_RESERVADA">
    
    public EntNumeroSerieSolicitacao sequenciaInicialReservada(Integer value) {
        setSequenciaInicialReservada(value);
        return this;
    }
    
    public void setSequenciaInicialReservada(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifySequenciaInicialReservada();
        } else {
            aSequenciaInicialReservada.setValue(value.getValue());
            if (aSequenciaInicialReservada.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSequenciaInicialReservada(String value) {
        if (value == null) {
            nullifySequenciaInicialReservada();
        } else {
            aSequenciaInicialReservada.setValue(value);
            if (aSequenciaInicialReservada.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSequenciaInicialReservada(Integer value) {
        aSequenciaInicialReservada.setValue(value);
        if (aSequenciaInicialReservada.isModified()) {
            setModified(true);
        }
    }
    
    public void setSequenciaInicialReservada(Object value) {
        aSequenciaInicialReservada.setValue(value);
        if (aSequenciaInicialReservada.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySequenciaInicialReservada() {
        if (!aSequenciaInicialReservada.isNull()) {
            aSequenciaInicialReservada.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getSequenciaInicialReservada() {
        return aSequenciaInicialReservada;
    }
    
    public DomInteger oldSequenciaInicialReservada() {
        return oSequenciaInicialReservada;
    }
    
    public Integer valueOfSequenciaInicialReservada() {
        return aSequenciaInicialReservada.getValue();
    }
    
    public boolean isSequenciaInicialReservadaModified() {
        return aSequenciaInicialReservada.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SEQUENCIA_FINAL_RESERVADA">
    
    public EntNumeroSerieSolicitacao sequenciaFinalReservada(Integer value) {
        setSequenciaFinalReservada(value);
        return this;
    }
    
    public void setSequenciaFinalReservada(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifySequenciaFinalReservada();
        } else {
            aSequenciaFinalReservada.setValue(value.getValue());
            if (aSequenciaFinalReservada.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSequenciaFinalReservada(String value) {
        if (value == null) {
            nullifySequenciaFinalReservada();
        } else {
            aSequenciaFinalReservada.setValue(value);
            if (aSequenciaFinalReservada.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSequenciaFinalReservada(Integer value) {
        aSequenciaFinalReservada.setValue(value);
        if (aSequenciaFinalReservada.isModified()) {
            setModified(true);
        }
    }
    
    public void setSequenciaFinalReservada(Object value) {
        aSequenciaFinalReservada.setValue(value);
        if (aSequenciaFinalReservada.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySequenciaFinalReservada() {
        if (!aSequenciaFinalReservada.isNull()) {
            aSequenciaFinalReservada.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getSequenciaFinalReservada() {
        return aSequenciaFinalReservada;
    }
    
    public DomInteger oldSequenciaFinalReservada() {
        return oSequenciaFinalReservada;
    }
    
    public Integer valueOfSequenciaFinalReservada() {
        return aSequenciaFinalReservada.getValue();
    }
    
    public boolean isSequenciaFinalReservadaModified() {
        return aSequenciaFinalReservada.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ULTIMA_SEQUENCIA_UTILIZADA">
    
    public EntNumeroSerieSolicitacao ultimaSequenciaUtilizada(Integer value) {
        setUltimaSequenciaUtilizada(value);
        return this;
    }
    
    public void setUltimaSequenciaUtilizada(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyUltimaSequenciaUtilizada();
        } else {
            aUltimaSequenciaUtilizada.setValue(value.getValue());
            if (aUltimaSequenciaUtilizada.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setUltimaSequenciaUtilizada(String value) {
        if (value == null) {
            nullifyUltimaSequenciaUtilizada();
        } else {
            aUltimaSequenciaUtilizada.setValue(value);
            if (aUltimaSequenciaUtilizada.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setUltimaSequenciaUtilizada(Integer value) {
        aUltimaSequenciaUtilizada.setValue(value);
        if (aUltimaSequenciaUtilizada.isModified()) {
            setModified(true);
        }
    }
    
    public void setUltimaSequenciaUtilizada(Object value) {
        aUltimaSequenciaUtilizada.setValue(value);
        if (aUltimaSequenciaUtilizada.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyUltimaSequenciaUtilizada() {
        if (!aUltimaSequenciaUtilizada.isNull()) {
            aUltimaSequenciaUtilizada.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getUltimaSequenciaUtilizada() {
        return aUltimaSequenciaUtilizada;
    }
    
    public DomInteger oldUltimaSequenciaUtilizada() {
        return oUltimaSequenciaUtilizada;
    }
    
    public Integer valueOfUltimaSequenciaUtilizada() {
        return aUltimaSequenciaUtilizada.getValue();
    }
    
    public boolean isUltimaSequenciaUtilizadaModified() {
        return aUltimaSequenciaUtilizada.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            e = new AdsException("ZTEST.NUMERO_SERIE_SOLICITACAO.GET_ERRORS_UNKNOWN",
                    AdsException.UNKNOWN,
                    "Erro não esperado: " + errorMsg);
        } else {
            if (msg.indexOf("UK_NUSESO_ANO_NUMERO") >= 0) {
                e = new AdsException("ZTEST.NUMERO_SERIE_SOLICITACAO.UK_NUSESO_ANO_NUMERO", 
                        Severity.ERROR,
                        "Registro duplicado! Ano do número de série deve ser único para uma solicitação Solicitação de ensaio ${SOLICITACAO_ENSAIO_ID}, Ano do número de série ${ANO} (UK_NUSESO_ANO_NUMERO)");
                return e;
            } else if (msg.indexOf("FK_NUSESO_SOLICITACAO_ENSAIO") >= 0) {
                e = new AdsException("ZTEST.NUMERO_SERIE_SOLICITACAO.FK_NUSESO_SOLICITACAO_ENSAIO", 
                        Severity.ERROR,
                        "Registro não cadastrado para SOLICITACAO_ENSAIO! (FK_NUSESO_SOLICITACAO_ENSAIO)");
                return e;
            } else if (msg.indexOf("PK_NUSESO") >= 0) {
                e = new AdsException("ZTEST.NUMERO_SERIE_SOLICITACAO.PK_NUSESO", 
                        Severity.ERROR,
                        "ID duplicado! (PK_NUSESO)");
                return e;
            } else {
                e = new AdsException("ZTEST.NUMERO_SERIE_SOLICITACAO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aSolicitacaoEnsaioId);
            allAttributes.add(aAno);
            allAttributes.add(aSequenciaInicialReservada);
            allAttributes.add(aSequenciaFinalReservada);
            allAttributes.add(aUltimaSequenciaUtilizada);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getSolicitacaoEnsaioId().toString() +
                " " + getAno().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findBySolicitacaoEnsaioIdAno(long solicitacaoEnsaioId, int ano) throws AdsException {
        findBy(new String[] {"SOLICITACAO_ENSAIO_ID", "ANO"},
                new Object[] {solicitacaoEnsaioId, ano});
    }
    
    private EntSolicitacaoEnsaio eSolicitacaoEnsaio;
    
    public EntSolicitacaoEnsaio findSolicitacaoEnsaio() throws AdsException {
        if (getSolicitacaoEnsaioId().isNull()) {
            return null;
        }
        if (eSolicitacaoEnsaio == null || !valueOfSolicitacaoEnsaioId().equals(eSolicitacaoEnsaio.valueOfId())) {
            eSolicitacaoEnsaio = new EntSolicitacaoEnsaio(ctx);
            eSolicitacaoEnsaio.find(valueOfSolicitacaoEnsaioId());
        }
        return eSolicitacaoEnsaio;
    }
    
    /**
     * Ativa o join desta entidade com SOLICITACAO_ENSAIO
     * através do atributo SOLICITACAO_ENSAIO_ID
     */
    public EntSolicitacaoEnsaio joinSolicitacaoEnsaio() {
        return joinSolicitacaoEnsaio(null);
    }
    public EntSolicitacaoEnsaio joinSolicitacaoEnsaio(String alias) {
        EntSolicitacaoEnsaio entity = new EntSolicitacaoEnsaio(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getSolicitacaoEnsaioId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findBySolicitacaoEnsaio(long id, String sqlAppend) throws AdsException {
        find("select ID from NUMERO_SERIE_SOLICITACAO where SOLICITACAO_ENSAIO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findBySolicitacaoEnsaio(long id) throws AdsException {
        findBySolicitacaoEnsaio(id,"");
    }
    
    public void findBySolicitacaoEnsaio(Entity entidade) throws AdsException {
        findBySolicitacaoEnsaio(entidade.valueOfId(),"");
    }
    
    public void findBySolicitacaoEnsaio(Entity entidade, String sqlAppend) throws AdsException {
        findBySolicitacaoEnsaio(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        eSolicitacaoEnsaio = null;
    }
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oUltimaSequenciaUtilizada.setValue(aUltimaSequenciaUtilizada);
        oSequenciaFinalReservada.setValue(aSequenciaFinalReservada);
        oSequenciaInicialReservada.setValue(aSequenciaInicialReservada);
        oAno.setValue(aAno);
        oSolicitacaoEnsaioId.setValue(aSolicitacaoEnsaioId);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntNumeroSerieSolicitacao.class);
            rule.setName("PK_NUSESO");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntNumeroSerieSolicitacao.class);
            rule.setAssociatedEntity(EntSolicitacaoEnsaio.class);
            rule.setName("FK_NUSESO_SOLICITACAO_ENSAIO");
            rule.addAttribute(new DomId("SOLICITACAO_ENSAIO_ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntNumeroSerieSolicitacao.class);
            rule.setName("UK_NUSESO_ANO_NUMERO");
            rule.addAttribute(new DomId("SOLICITACAO_ENSAIO_ID",""));
            rule.addAttribute(new DomInteger("ANO",""));
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
}
